Installation

Cargo

First you need to install the crate by adding this entry to your Cargo.toml dependencies list:

bevy_mod_scripting = { version = "0.9.0", features = ["lua54"]}

Choose the language features you wish enabled and add them to the features block.

Bevy Plugin

The next step is to add the BMS plugin to your application, on top of any other extras you want included in your app:

app.add_plugins((
    LuaScriptingPlugin::default(),
    ScriptFunctionsPlugin
));

The above is how you'd setup BMS for Lua, if you want to use another language, simply use a corresponding plugin from the integration crate.

Language Features

Each language supported by BMS can be switched-on via feature flag as below:

Language	Feature Flag
Lua51	lua51
Lua52	lua54
Lua53	lua53
Lua54	lua54
Luajit	luajit
Luajit52	luajit52
Luau	luau
Rhai	rhai
Rune	rune

Extra Features

In order to fit as many use cases as possible, BMS allows you to disable a lot of its functionality.

By default all of the useful features are enabled, but you may disable them if you wish if you are only needing BMS for script lifecycle management, and want to populate the bindings yourself.

Feature	Description
core_functions	If enabled, will enable all core functions, i.e. bevy integrations which let you interact with Bevy via reflection
bevy_bindings	If enabled, populates the function registry with additiona automatically generated bevy bindings. This includes functions on `glam` and `bevy::ecs` types. These are useful but will slow down compilation considerably.
mlua_async	Enables `mlua/async`
mlua_serialize	Enables `mlua/serialize`
mlua_macros	Enables `mlua/macros`
unsafe_lua_modules	Allows loading unsafe modules via `require` in lua

Managing Scripts

Scripts live in the standard bevy assets directory. Loading a script means:

Parsing the script body
Creating or updating the resources which store script state
Assigning a name/id to the script so it can be referred to by the rest of the application.

Loading

BMS listens to ScriptAsset events and reacts accordingly. In order to load a script, all you need to do is request a handle to it via the asset server and store it somewhere.

Below is an example system which loads a script called assets/my_script.lua and stores the handle in a local system parameter:

fn load_script(server: Res<AssetServer>, mut handle: Local<Handle<ScriptAsset>>) {
    let handle_ = server.load::<ScriptAsset>("my_script.lua");
    *handle = handle_;
}

In practice you will likely store this handle in a resource or component, when your load all the scripts necessary for your application.

Unloading

Scripts are automatically unloaded when the asset is dropped. This means that if you have a handle to a script and it goes out of scope, the script will be unloaded.

This will delete references to the script and remove any internal handles to the asset. You will also need to clean up any handles to the asset you hold in your application in order for the asset to be unloaded.

Hot-loading scripts

To enable hot-loading of assets, you need to enable the necessary bevy features as normal see the bevy cheatbook for instructions.

Assuming that hot-reloading is enabled for your app, any changes to script assets will automatically be picked up and the scripts re-loaded.

File Extensions

Normally the set of supported extensions is pre-decided by each language plugin.

I.e. Lua supports ".lua" extensions and Rhai supports ".rhai" extensions.

Scripts are mapped to the corresponding language plugin based on these and so it's important to use them correctly.

If you would like to add more extensions you need to populate them via app.add_supported_script_extensions.

Advanced

Normally not necessary, but knowing these exist could be useful for more advanced use cases.

Manually (re)loading scripts

In order to manually re-load or load a script you can issue the CreateOrUpdateScript command:

CreateOrUpdateScript::<LuaScriptingPlugin>::new("my_script.lua".into(), "print(\"hello world from new script body\")".into(), asset_handle)

replace LuaScriptingPlugin with the scripting plugin you are using.

Manually Deleting scripts

In order to delete a previously loaded script, you will need to issue a DeleteScript command like so:

DeleteScript::<LuaScriptingPlugin>::new("my_script.lua".into())

replace LuaScriptingPlugin with the scripting plugin you are using.

Loading/Unloading timeframe

Scripts asset events are processed within the same frame they are issued. This means the moment an asset is loaded, it should be loaded and ready to use in the Update schedule. Similarly, the moment an asset is deleted, it should be unloaded and no longer usable in the Update schedule.

Attaching Scripts

Once you have scripts discovered and loaded, you'll want to run them.

At the moment BMS supports three methods of making scripts runnable:

Attaching them to entities via ScriptComponent's
Adding static scripts
Creating dynamic systems ⚗️ (see the script systems section)

And then sending script event's which trigger callbacks on the scripts.

Attaching scripts to entities

In order to attach a script and make it runnable simply add a ScriptComponent to an entity

    commands.entity(my_entity).insert(ScriptComponent::new(vec!["my_script.lua", "my_other_script.lua"]));

When this script is run the entity global will represent the entity the script is attached to. This allows you to interact with the entity in your script easilly.

Be wary of path separators, by default script ID's are derived from asset paths, which are platform dependent. Make sure to use `std::path::PathBuf` if you are targetting multiple platforms.

Making static scripts runnable

Some scripts do not require attaching to an entity. You can run these scripts by loading them first as you would with any other script, then either adding them at app level via add_static_script or by issuing a AddStaticScript command like so:

    commands.queue(AddStaticScript::new("my_static_script.lua"));

The script will then be run as any other script but without being attached to any entity. and as such the entity global will always represent an invalid entity.

Note: Internally these scripts are attached to a dummy entity and as such you can think of them as being attached to an entity with an id of 0.

Running Scripts

Scripts can run logic either when loaded or when triggered by an event. For example the script:

print("hello from load time")
function on_event(arg1)
    print("hello from event time")
    print(arg1)
end

Will print "hello from load time" when the script is loaded, and "hello from event time" when the script receives an event targeting the on_event callback with a receiver list including this script or entity.

In order to trigger on_event you need to first define a label, then send an event containing the label:


#[derive(Reflect)]
pub struct MyReflectType;

// define the label, you can define as many as you like here
callback_labels!(OnEvent => "on_event");

// trigger the event
fn send_event(mut writer: EventWriter<ScriptCallbackEvent>, mut allocator: ResMut<AppReflectAllocator>) {

    let allocator = allocator.write();
    let my_reflect_payload = ReflectReference::new_allocated(MyReflectType, &mut allocator);

    writer.send(ScriptCallbackEvent::new_for_all(
        OnEvent,
        vec![my_reflect_payload.into()],
    ));
}

Note the second argument is the payload we are sending with the event, in this case we are sending an arbitrary reflect type MyReflectType. This can be any type you like, as long as it implements Reflect.

Other variants of the ScriptValue enum are available for sending different types of data, such as ScriptValue::Integer for primtive, types.

Event Handlers

In order for the events you send to actually be picked up, you need to inject special systems into your application. These systems will listen for the events and trigger the appropriate callbacks on the scripts:

app.add_systems(Update, event_handler::<OnEvent, LuaScriptingPlugin>);

Note the system is parameterized by the label we defined earlier, and the scripting plugin we are using. You can add as many of these systems as you like.

The event handler will catch all events with the label OnEvent and trigger the on_event callback on all targeted scripts which have that callback defined.

In order to handle events in the same frame and not accidentally have events "spill over" into the next frame, you should make sure to order any systems which produce these events before the event handler systems.

Controlling Script Bindings

In this book we refer to anything accessible by a script, which allows it to communicate with your Rust code a binding (which in previous versions was more generically referred to as a script API).

The "binding" here being used as in: binding script code to rust code.

Namespaces

Namespaces are a way to group functions together, and are used to prevent naming conflicts. You can have multiple namespaces, and each namespace can have multiple functions.

Language implementations will also look for specific functions registered on your type first before looking at the generic ReflectReference namespace.

Dynamic Functions

Everything callable by scripts must first be registered in the dynamic function registry. Notably we do not make use of the normal bevy function registry to improve performance and usability. This means you cannot call just any function.

In order for a function to be callable by a script it must adhere to a few requirements:

Each argument must implement FromScript.
Each return type must implement IntoScript.
Each argument must also implement GetTypeDependencies
Each return type must also implement GetTypeDependencies

The into/from requirements allow us to convert these types to ScriptValue's, and each supported scripting language can then marshall these into the script.

Note these types are implemented for primitives, but if you want to interact with one of your Reflect implementing types, you will need to use one of Ref<T>, Mut<T> or Val<T> wrappers in place of &T, &mut T and T respectively.

These wrappers enable us to safely interact with bevy, and claim any necessary mutex'es on Resources, Components or Allocations.

The GetTypeDependencies, trait is simply a local trait alias for GetTypeRegistration with less strict type requirements. It allows us to register all the types necessary for the function calls, so that you don't have to register anything manually. If your type implements GetTypeRegistration you should not face any issues on this front.

Registering Script Functions

Registering functions can be done via the NamespaceBuilder like below:

    NamespaceBuilder::<ReflectReference>::new(&mut world)
        .register(
            "hello_world",
            |s: String| {
                println!(s)
            },
        );

    NamespaceBuilder::<GlobalNamespace>::new_unregistered(&mut world)
        .register(
            "hello_world2",
            |s: String| {
                println!(s)
            },
        );

This will allow you to call this function within lua like so:

some_type:hello_world("hi from method!");
hello_world2("hi from global!");

Note the new_unregistered call instead of new, this is because GlobalNamespace is not a Reflect type, and the new call also automatically registers the type in the reflection registry.

Macros

The above is a bit tedious, so instead you can use the script_bindings macro, which applies to impl blocks like so:

#[script_bindings("test_fn")]
impl TestStruct {
    /// My docs !!
    /// 
    /// Arguments:
    /// * `_self` - the first argument
    /// * `arg1` - the second argument
    /// Returns:
    /// * `return` - nothing
    fn test_fn(_self: Ref<TestStruct>, mut arg1: usize) {}
}


pub fn main() {
    let mut app = App::new();
    register_test_fn(app.world_mut())
}

Note the documentation will automatically be picked up and stored for the purposes of reflection and documentation generation, including argument/return type specific docs.

Context Arguments

Each script function call always receives an additional context argument: FunctionCallContext. You can opt-in to receive this argument in your own function definitions by adding it as the first argument.

The context contains requests from the caller to your function, such as "I am calling you from a 1-indexed array system, please convert the index first", This argument is only relevant if you're targeting multiple languages.

It also allows you to retrieve the world via FunctionCallContext::world().

You can use this as follows:

    NamespaceBuilder::<ReflectReference>::new(&mut world)
        .register(
            "hello_world",
            |ctx: FunctionCallContext, s: String| {
                let world = ctx.world()?;
                let should_use_0_indexing = ctx.convert_to_0_indexed;
                println!(should_use_0_indexing);
                println!(s)
                Ok(())
            },
        );

Generic Arguments

Sometimes you might want to be generic over the type of argument you're accepting, you can do so by accepting ScriptValue arguments like so:

    NamespaceBuilder::<ReflectReference>::new(&mut world)
        .register(
            "is_integer",
            |s: ScriptValue| {
                match s {
                    ScriptValue::Integer(i) => true,
                    _ => false
                }
            },
        );

You can treat return values similarly.

Fallible functions

Your script functions can return errors either by:

Returning Result<T: IntoScript, InteropError>
Returning ScriptValue and manually creating the ScriptValue::Error(into_interop_erorr.into()) variant.

Reserved Functions

There are a few reserved functions that you can override by registering them on a specific type:

Function Name	Description	Overridable?	Has Default Implementation?
get	a getter function, used for indexing into a type	✅	✅
set	a setter function, used for setting a value on a type	✅	✅
sub	a subtraction function, used for subtracting two values	✅	❌
add	an addition function, used for adding two values	✅	❌
mul	a multiplication function, used for multiplying two values	✅	❌
div	a division function, used for dividing two values	✅	❌
rem	a remainder function, used for getting the remainder of two values	✅	❌
neg	a negation function, used for negating a value	✅	❌
pow	a power function, used for raising a value to a power	✅	❌
eq	an equality function, used for checking if two values are equal	✅	❌
lt	a less than function, used for checking if a value is less than another	✅	❌
iter	an iterator function, used for iterating over a value	❌	✅
display_ref	a display function, used for displaying a reference to a value	❌	✅
display_value	a display function, used for displaying a mutable reference to a value	❌	✅

In this context overridable indicates whether language implementations will look for a specific function on your type before looking at the generic ReflectReference namespace. You can still remove the existing registration for these functions on the ReflectReference namespace if you want to replace them with your own implementation.

Modifying Script Contexts

You should be able to achieve what you need by registering script functions in most cases. However sometimes you might want to override the way contexts are loaded, or how the runtime is initialized.

This is possible using Context Initializers and Context Pre Handling Initializers as well as Runtime Initializers.

It is however always reccomened to use the dynamic script function registry whenever possible, as it is more flexible and easier to use. It also allows you to introspect available functions easier.

Context Initializers

For example, let's say you want to set a dynamic amount of globals in your script, depending on some setting in your app.

You could do this by customizing the scripting plugin:

let plugin = LuaScriptingPlugin::default().add_context_initializer(|script_id: &str, context: &mut Lua| {
    let globals = context.globals();
    for i in 0..10 {
        globals.set(i, i);
    }
    Ok(())
});

app.add_plugins(plugin)

The above will run every time the script is loaded or re-loaded and before it handles any callbacks.

Context Pre Handling Initializers

If you want to customize your context before every time it's about to handle events (and when it's loaded + reloaded), you can use Context Pre Handling Initializers:

let plugin = LuaScriptingPlugin::default().add_context_pre_handling_initializer(|script_id: &str, entity: Entity, context: &mut Lua| {
    let globals = context.globals();
    globals.set("script_name", script_id.to_owned());
    Ok(())
});

Runtime Initializers

Some scripting languages, have the concept of a runtime. This is a global object which is shared between all contexts. You can customize this object using Runtime Initializers:

let plugin = SomeScriptingPlugin::default().add_runtime_initializer(|runtime: &mut Runtime| {
    runtime.set_max_stack_size(1000);
    Ok(())
});

In the case of Lua, the runtime type is () i.e. This is because mlua does not have a separate runtime concept.

Accessing the World in Initializers

You can access the world in these initializers by using the thread local: ThreadWorldContainer:


let plugin = LuaScriptingPlugin::default();
plugin.add_context_initializer(|script_id: &str, context: &mut Lua| {
    let world = ThreadWorldContainer.try_get_world().unwrap();
    world.with_resource::<MyResource>(|res| println!("My resource: {:?}", res));
    Ok(())
});

Shared Contexts

By default BMS will create an individual script context, or sandbox, for each script that is run. This means that each script will have its own set of global variables and functions that are isolated from other scripts. However, sometimes this might not be desirable, if you aren't worried about scripts interfering with each other, or if you want to easilly share data between scripts. In these cases, you can use shared contexts.

Enabling Shared Contexts

You can enable shared contexts by configuring the relevant scripting plugin like so:

let mut plugin = LuaScriptingPlugin::default().enable_context_sharing();

app.add_plugins(plugin);

Context Loading Settings

All context loading settings are stored in a separate resource per scripting plugin namely: ContextLoadingSettings<Plugin>.

The settings are as follows:

loader - the load and unload strategy for contexts. Each scripting plugin will have a load and unload function which is hooked up through here
assigner - the strategy for assigning/unassigning contexts to scripts. This is used to determine how to assign a context to a script when it is run, and what to do with the context when the script is finished.
context_initializers - stores all context initializers for the plugin
context_pre_handling_initializers - stores all context pre-handling initializers for the plugin

More advanced applications might want to customize these settings to suit their needs.

Script ID mapping

Every script is currently identified by a unique ID.

ID's are derived from the script asset path for scripts loaded via the asset system.

By default this is an identity mapping, but you can override this by modifying the AssetPathToScriptIdMapper inside the ScriptAssetSettings resource before loading the script.

Be wary of path separators, by default script ID's are derived from asset paths, which are platform dependent. Make sure to use `std::path::PathBuf` if you are targetting multiple platforms.

Script Systems

Script systems are an experimental feature

It's possible within BMS to inject new systems from within scripts themselves.

Systems introduced by scripts can run in parallel to other systems, and can be freely inserted between any other system, including other script systems.

BMS also provides utilities for visualising schedules using dot graphs, allowing low-effort modding frameworks for game authors.

Schedules

Bevy doesn't support reflecting schedules, so BMS rolls it's own schedule registry resource: AppScheduleRegistry, which can be used to add any custom schedules you want to interact with. The default Bevy schedules will be pre-populated for you.

Once you've registered your schedule you will be able to interact with it in scripts like below:

local update_schedule = world.get_schedule_by_name("Update")
local systems = update:systems()
local system_with_name = update:get_system_by_name("my_system")

Inserting Systems

To insert a system you will need to use the system_builder global function like below:

local system = system_builder("my_system", script_id)
    :exclusive()
    :after(some_other_system)
    :before(another_system)

This will let you call world.add_system like so:

world.add_system(update_schedule,system)

If your event handler running the script is running in a certain schedule, that schedule will be temporarilly removed by Bevy. Meaning you won't be able to modify it from within the script in-flight.

Parameters

The system builder allows script authors to parameterise systems, using resource and query functions. The order in which those functions are called, will define the order in which arguments will be provided to the specified script callback.

For example:

system_builder("my_system")
    :query(
        world.query()
            :component(ComponentA)
            :component(ComponentB)
            :with(ComponentC)
            :without(ComponentD)
    )
    :resource(ResourceA)

will create a system which calls the specified callback my_system with 2 arguments:

The ScriptQueryResult for the first query
- With components access to ComponentA and ComponentB
The ReflectReference to ResourceA

Exclusive systems

An exclusive system can be created using the exclusive function call on the system builder.

This allows the system to access everything as in a normal event handler.

Non-exclusive systems, will only be able to access the set of components and resources as parameterized when building the system. This is why we can run the system in parallel to other non-overlapping systems.

Exclusive systems on the other hand, cannot run in parallel.

Callback

The system injected will be similar to an event handler, however it will only trigger the specified script, and without any entity, in the first example you'd see the following lua callback:

function my_system()
    print("I am a dynamic system")
end

get triggered every update.

Examples

In the future we hope to embedd live WASM code examples into the documentation, for now the best source of example scripts will be our regression test suite available in all supported languages in our github repository.

For rust examples see this folder.

Scripting Reference

This part of the book covers the user-facing API of the scripting languages supported by BMS. This will be where you will want to forward your script users to get started with scripting in BMS.

If you are a modder, welcome! 👋, apologies for the rust-centricity of this guide, we are working on it!

Globals

Scripts will have access to a few global variables in most callbacks:

world: a static reference to the world, with all sorts of functions available
entity: the entity the script is attached to, not available on load/unload callbacks, and in dynamic system callbacks.
script_id: the ID of the current script

Constructing Arbitrary Types

When interfacing with bevy, we do this via reflection. While the generated bindings do not cover constructors for every single type that bevy or other libraries provide, reflection allows us to construct some (not all types implement FromReflect) types from dynamic structs.

BMS exposes this ability to all script writers via the construct global function.

Structs

The following struct:

pub struct MyStruct {
    pub my_field: String
}

can be constructed from lua like so:

local MyStruct = types.MyStruct
local concrete_my_struct = construct(MyStruct, {
    my_field = "hello"
})

Tuple Structs

The following tuple struct:


pub struct MyTupleStruct(pub String);

can be constructed like so:


local MyTupleStruct = types.MyTupleStruct
local concrete_my_tuple_struct = construct(MyTupleStruct, {
    _1 = "hello"
})

Enums

The following enum:

pub enum MyEnum {
    VariantA {
        field: String
    },
    VariantB
}

can be constructed like so:


local MyEnum = types.MyEnum
local variantA = construct(MyEnum, {
    variant = "VariantA",
    field = "hello"
})
local variantB = construct(MyEnum, {
    variant = "VariantB"
})

When working with enums you can also figure out the variant at runtime using variant_name:

if my_enum:variant_name() == "VariantA" then
    print(my_enum.field)
end

Core Bindings

This is an automatically generated file, you'll find links to the contents below

Section	Contents
`Types`	Describes all available binding types
`Global Functions`	Documents all the global functions present in the bindings
`Globals`	Documents all global variables present in the bindings

Globals

Global Values

Global values that are accessible anywhere inside scripts. You should avoid naming conflicts with these and trying to overwrite or edit them.

Instances

Instances containing actual accessible values.

Instance	Type
`types`	HashMap<String, ScriptTypeRegistration \| ScriptComponentRegistration \| ScriptResourceRegistration>
`entity`	Entity
`script_id`	String
`world`	World

Static Instances

Static type references, existing for the purpose of typed static function calls.

Instance	Type
`ActiveAnimation`	ActiveAnimation
`ScreenshotCaptured`	ScreenshotCaptured
`Projection`	Projection
`ImageNode`	ImageNode
`ScriptComponentRegistration`	ScriptComponentRegistration
`PickingInteraction`	PickingInteraction
`JustifySelf`	JustifySelf
`ScrollPosition`	ScrollPosition
`CursorOptions`	CursorOptions
`Affine3`	Affine3
`ClusterConfig`	ClusterConfig
`Cascades`	Cascades
`SubCameraView`	SubCameraView
`RepeatAnimation`	RepeatAnimation
`Cascade`	Cascade
`UvChannel`	UvChannel
`ScreenSpaceReflections`	ScreenSpaceReflections
`EnvironmentMapLight`	EnvironmentMapLight
`Hwba`	Hwba
`AtomicBool`	AtomicBool
`ClusterZConfig`	ClusterZConfig
`EnabledButtons`	EnabledButtons
`Rect`	Rect
`Interaction`	Interaction
`ThreadedAnimationGraphs`	ThreadedAnimationGraphs
`TextLayout`	TextLayout
`MipBias`	MipBias
`GamepadRumbleRequest`	GamepadRumbleRequest
`Camera2d`	Camera2d
`CascadesVisibleEntities`	CascadesVisibleEntities
`DebandDither`	DebandDither
`Visibility`	Visibility
`WindowLevel`	WindowLevel
`MonitorSelection`	MonitorSelection
`RawGamepadEvent`	RawGamepadEvent
`i32`	i32
`SceneRoot`	SceneRoot
`OnAdd`	OnAdd
`RelativeCursorPosition`	RelativeCursorPosition
`IRect`	IRect
`RayId`	RayId
`OverflowClipMargin`	OverflowClipMargin
`AlphaMode2d`	AlphaMode2d
`ContrastAdaptiveSharpening`	ContrastAdaptiveSharpening
`AlignContent`	AlignContent
`Stopwatch`	Stopwatch
`MouseButton`	MouseButton
`InheritedVisibility`	InheritedVisibility
`MeshMorphWeights`	MeshMorphWeights
`RenderAssetUsages`	RenderAssetUsages
`Arc2d`	Arc2d
`Mesh3d`	Mesh3d
`I64Vec2`	I64Vec2
`TextColor`	TextColor
`RangeFull`	RangeFull
`Sphere`	Sphere
`OrthographicProjection`	OrthographicProjection
`LightGizmoConfigGroup`	LightGizmoConfigGroup
`Volume`	Volume
`OpaqueRendererMethod`	OpaqueRendererMethod
`DepthPrepass`	DepthPrepass
`TouchPhase`	TouchPhase
`HitData`	HitData
`OnRemove`	OnRemove
`GamepadAxis`	GamepadAxis
`BVec4`	BVec4
`UVec2`	UVec2
`AtomicI8`	AtomicI8
`i64`	i64
`PointerPress`	PointerPress
`GamepadConnection`	GamepadConnection
`PickingBehavior`	PickingBehavior
`U64Vec2`	U64Vec2
`TextBounds`	TextBounds
`ButtonAxisSettings`	ButtonAxisSettings
`Affine3A`	Affine3A
`AssetIndex`	AssetIndex
`Vec3`	Vec3
`Ray2d`	Ray2d
`UiRect`	UiRect
`AlignSelf`	AlignSelf
`GizmoLineStyle`	GizmoLineStyle
`Exposure`	Exposure
`KeyboardFocusLost`	KeyboardFocusLost
`Cylinder`	Cylinder
`TemporalJitter`	TemporalJitter
`ColorGradingGlobal`	ColorGradingGlobal
`Oklcha`	Oklcha
`AabbCast3d`	AabbCast3d
`BorderRect`	BorderRect
`SpatialScale`	SpatialScale
`PointerLocation`	PointerLocation
`ScreenSpaceTransmissionQuality`	ScreenSpaceTransmissionQuality
`AnimationGraphHandle`	AnimationGraphHandle
`SpriteSource`	SpriteSource
`f32`	f32
`WindowCloseRequested`	WindowCloseRequested
`Text2d`	Text2d
`Gamepad`	Gamepad
`BorderColor`	BorderColor
`CircularSector`	CircularSector
`Rot2`	Rot2
`Mesh2d`	Mesh2d
`Plane3d`	Plane3d
`GlobalVolume`	GlobalVolume
`RawGamepadButtonChangedEvent`	RawGamepadButtonChangedEvent
`FunctionCallContext`	FunctionCallContext
`Quat`	Quat
`PointLight`	PointLight
`SkinnedMesh`	SkinnedMesh
`Hsla`	Hsla
`AnimationTargetId`	AnimationTargetId
`Outline`	Outline
`NormalPrepass`	NormalPrepass
`InfinitePlane3d`	InfinitePlane3d
`Aabb3d`	Aabb3d
`UiBoxShadowSamples`	UiBoxShadowSamples
`SystemCursorIcon`	SystemCursorIcon
`DirectionalLight`	DirectionalLight
`NoFrustumCulling`	NoFrustumCulling
`ScriptResourceRegistration`	ScriptResourceRegistration
`CursorIcon`	CursorIcon
`TextFont`	TextFont
`LinearRgba`	LinearRgba
`TextureAtlasLayout`	TextureAtlasLayout
`u32`	u32
`TextureAtlas`	TextureAtlas
`u64`	u64
`CircularSegment`	CircularSegment
`Label`	Label
`BloomCompositeMode`	BloomCompositeMode
`Xyza`	Xyza
`u16`	u16
`Children`	Children
`WindowResizeConstraints`	WindowResizeConstraints
`ClearColorConfig`	ClearColorConfig
`ZIndex`	ZIndex
`RotationGesture`	RotationGesture
`NativeKeyCode`	NativeKeyCode
`KeyCode`	KeyCode
`i128`	i128
`ComputedTextBlock`	ComputedTextBlock
`PinchGesture`	PinchGesture
`WindowPosition`	WindowPosition
`NodeIndex`	NodeIndex
`Laba`	Laba
`RemovedComponentEntity`	RemovedComponentEntity
`GizmoLineJoint`	GizmoLineJoint
`EulerRot`	EulerRot
`InteropError`	InteropError
`I64Vec4`	I64Vec4
`Button`	Button
`Overflow`	Overflow
`FileDragAndDrop`	FileDragAndDrop
`TextureSlicer`	TextureSlicer
`GamepadButton`	GamepadButton
`CameraRenderGraph`	CameraRenderGraph
`DirectionalLightShadowMap`	DirectionalLightShadowMap
`ReflectReference`	ReflectReference
`CompassQuadrant`	CompassQuadrant
`AnimationClip`	AnimationClip
`UiScale`	UiScale
`UVec4`	UVec4
`Circle`	Circle
`TextNodeFlags`	TextNodeFlags
`DynamicScriptFunctionMut`	DynamicFunctionMut
`Anchor`	Anchor
`Triangle3d`	Triangle3d
`ShadowFilteringMethod`	ShadowFilteringMethod
`WindowMoved`	WindowMoved
`RequestRedraw`	RequestRedraw
`Parent`	Parent
`AnimationEventTarget`	AnimationEventTarget
`GamepadRumbleIntensity`	GamepadRumbleIntensity
`Window`	Window
`AlignItems`	AlignItems
`Fixed`	Fixed
`SmolStr`	SmolStr
`PointerId`	PointerId
`AtomicUsize`	AtomicUsize
`Entity`	Entity
`MinTrackSizingFunction`	MinTrackSizingFunction
`SystemIdMarker`	SystemIdMarker
`AssetPath`	AssetPath
`NonZeroI16`	NonZeroI16
`Vec3A`	Vec3A
`DAffine3`	DAffine3
`Line2d`	Line2d
`AmbientLight`	AmbientLight
`BoundingCircleCast`	BoundingCircleCast
`DMat3`	DMat3
`DVec2`	DVec2
`NonZeroU32`	NonZeroU32
`AtomicI16`	AtomicI16
`ViewVisibility`	ViewVisibility
`GamepadAxisChangedEvent`	GamepadAxisChangedEvent
`Image`	Image
`Sensitivity`	Sensitivity
`Segment2d`	Segment2d
`MouseScrollUnit`	MouseScrollUnit
`Display`	Display
`AccumulatedMouseScroll`	AccumulatedMouseScroll
`PointerInputPlugin`	PointerInputPlugin
`PanGesture`	PanGesture
`WindowResized`	WindowResized
`Identifier`	Identifier
`MouseWheel`	MouseWheel
`WindowDestroyed`	WindowDestroyed
`SpotLight`	SpotLight
`Mat3A`	Mat3A
`GamepadSettings`	GamepadSettings
`SpatialListener`	SpatialListener
`Cone`	Cone
`Camera`	Camera
`CompassOctant`	CompassOctant
`ChromaticAberration`	ChromaticAberration
`Tetrahedron`	Tetrahedron
`Virtual`	Virtual
`IVec3`	IVec3
`ComponentTicks`	ComponentTicks
`Cow`	Cow
`AccumulatedMouseMotion`	AccumulatedMouseMotion
`Oklaba`	Oklaba
`ColorMaterial`	ColorMaterial
`Name`	Name
`AabbGizmoConfigGroup`	AabbGizmoConfigGroup
`ClearColor`	ClearColor
`Annulus`	Annulus
`i16`	i16
`ColorGrading`	ColorGrading
`Frustum`	Frustum
`ScriptValue`	ScriptValue
`DepthOfField`	DepthOfField
`GridTrackRepetition`	GridTrackRepetition
`TextSpan`	TextSpan
`Smaa`	Smaa
`Real`	Real
`InternalWindowState`	InternalWindowState
`SyncToRenderWorld`	SyncToRenderWorld
`BoundingCircle`	BoundingCircle
`JustifyContent`	JustifyContent
`ComputedNode`	ComputedNode
`Dir3`	Dir3
`RenderLayers`	RenderLayers
`Rectangle`	Rectangle
`AspectRatio`	AspectRatio
`FlexWrap`	FlexWrap
`ManualTextureViewHandle`	ManualTextureViewHandle
`DefaultSpatialScale`	DefaultSpatialScale
`AnimationGraph`	AnimationGraph
`AtomicI64`	AtomicI64
`BoundingSphereCast`	BoundingSphereCast
`Cuboid`	Cuboid
`BorderRadius`	BorderRadius
`Screenshot`	Screenshot
`ParallaxMappingMethod`	ParallaxMappingMethod
`Ray3d`	Ray3d
`Isometry2d`	Isometry2d
`Key`	Key
`Fxaa`	Fxaa
`OverflowAxis`	OverflowAxis
`GamepadEvent`	GamepadEvent
`ScreenSpaceAmbientOcclusionQualityLevel`	ScreenSpaceAmbientOcclusionQualityLevel
`Aabb`	Aabb
`TouchInput`	TouchInput
`LightGizmoColor`	LightGizmoColor
`f64`	f64
`Mat4`	Mat4
`JustifyText`	JustifyText
`ImageNodeSize`	ImageNodeSize
`OrderIndependentTransparencySettings`	OrderIndependentTransparencySettings
`Viewport`	Viewport
`Timer`	Timer
`usize`	usize
`MaxTrackSizingFunction`	MaxTrackSizingFunction
`RawGamepadAxisChangedEvent`	RawGamepadAxisChangedEvent
`PointLightShadowMap`	PointLightShadowMap
`Lcha`	Lcha
`ConicalFrustum`	ConicalFrustum
`ReflectSystem`	ReflectSystem
`PresentMode`	PresentMode
`Monitor`	Monitor
`Color`	Color
`NativeKey`	NativeKey
`AnimationPlayer`	AnimationPlayer
`FogFalloff`	FogFalloff
`WindowRef`	WindowRef
`Arc`	Arc
`ScriptTypeRegistration`	ScriptTypeRegistration
`ClusterFarZMode`	ClusterFarZMode
`DVec4`	DVec4
`VolumetricLight`	VolumetricLight
`ButtonState`	ButtonState
`DAffine2`	DAffine2
`WindowMode`	WindowMode
`RayCast2d`	RayCast2d
`GizmoConfig`	GizmoConfig
`AtomicU8`	AtomicU8
`U64Vec4`	U64Vec4
`GlobalsUniform`	GlobalsUniform
`AnimationTransition`	AnimationTransition
`Tonemapping`	Tonemapping
`GlyphAtlasInfo`	GlyphAtlasInfo
`ReflectableScheduleLabel`	ReflectableScheduleLabel
`BloomPrefilter`	BloomPrefilter
`PlaybackSettings`	PlaybackSettings
`FlexDirection`	FlexDirection
`DynamicSceneRoot`	DynamicSceneRoot
`BoundingSphere`	BoundingSphere
`GridPlacement`	GridPlacement
`Affine2`	Affine2
`NotShadowReceiver`	NotShadowReceiver
`IVec4`	IVec4
`Bloom`	Bloom
`WindowThemeChanged`	WindowThemeChanged
`VisibleEntities`	VisibleEntities
`CursorMoved`	CursorMoved
`Segment3d`	Segment3d
`WindowFocused`	WindowFocused
`RenderTarget`	RenderTarget
`I64Vec3`	I64Vec3
`FontSmoothing`	FontSmoothing
`FocusPolicy`	FocusPolicy
`Uuid`	Uuid
`Camera3dDepthLoadOp`	Camera3dDepthLoadOp
`PositionType`	PositionType
`FunctionInfo`	FunctionInfo
`TextLayoutInfo`	TextLayoutInfo
`ReflectSchedule`	ReflectSchedule
`KeyboardInput`	KeyboardInput
`StandardMaterial`	StandardMaterial
`DoubleTapGesture`	DoubleTapGesture
`OnInsert`	OnInsert
`WindowClosed`	WindowClosed
`CascadeShadowConfig`	CascadeShadowConfig
`BVec4A`	BVec4A
`GltfMeshExtras`	GltfMeshExtras
`AtomicI32`	AtomicI32
`ScriptQueryResult`	ScriptQueryResult
`URect`	URect
`NotShadowCaster`	NotShadowCaster
`GltfMaterialName`	GltfMaterialName
`PointerInteraction`	PointerInteraction
`HierarchyEvent`	HierarchyEvent
`Tick`	Tick
`U64Vec3`	U64Vec3
`Sprite`	Sprite
`ButtonSettings`	ButtonSettings
`AtomicU32`	AtomicU32
`GlobalTransform`	GlobalTransform
`PositionedGlyph`	PositionedGlyph
`GridTrack`	GridTrack
`MotionVectorPrepass`	MotionVectorPrepass
`ScriptSystemBuilder`	ScriptSystemBuilder
`Isometry3d`	Isometry3d
`TypeId`	TypeId
`ContentSize`	ContentSize
`Triangle2d`	Triangle2d
`DVec3`	DVec3
`AabbCast2d`	AabbCast2d
`CubemapFrusta`	CubemapFrusta
`GltfExtras`	GltfExtras
`Camera3d`	Camera3d
`AxisSettings`	AxisSettings
`VideoMode`	VideoMode
`VolumetricFog`	VolumetricFog
`Mat3`	Mat3
`SliceScaleMode`	SliceScaleMode
`bool`	bool
`Mesh`	Mesh
`Namespace`	Namespace
`NonZeroU16`	NonZeroU16
`GizmoConfigStore`	GizmoConfigStore
`String`	String
`AnimationTarget`	AnimationTarget
`Node`	Node
`Ellipse`	Ellipse
`Instant`	Instant
`Transform`	Transform
`UVec3`	UVec3
`AppLifecycle`	AppLifecycle
`GamepadButtonChangedEvent`	GamepadButtonChangedEvent
`MouseButtonInput`	MouseButtonInput
`isize`	isize
`SpriteImageMode`	SpriteImageMode
`Mat2`	Mat2
`DQuat`	DQuat
`ForceTouch`	ForceTouch
`FunctionArgInfo`	FunctionArgInfo
`u8`	u8
`CompositeAlphaMode`	CompositeAlphaMode
`WindowClosing`	WindowClosing
`char`	char
`DistanceFog`	DistanceFog
`Torus`	Torus
`DepthOfFieldMode`	DepthOfFieldMode
`GamepadConnectionEvent`	GamepadConnectionEvent
`JustifyItems`	JustifyItems
`Indices`	Indices
`ColorGradingSection`	ColorGradingSection
`DiGraph`	DiGraph
`SmaaPreset`	SmaaPreset
`EaseFunction`	EaseFunction
`AnimationTransitions`	AnimationTransitions
`i8`	i8
`DMat2`	DMat2
`WindowScaleFactorChanged`	WindowScaleFactorChanged
`DMat4`	DMat4
`RayCast3d`	RayCast3d
`ResolvedBorderRadius`	ResolvedBorderRadius
`Capsule2d`	Capsule2d
`ScalingMode`	ScalingMode
`GltfMaterialExtras`	GltfMaterialExtras
`GltfSceneExtras`	GltfSceneExtras
`LightProbe`	LightProbe
`Interval`	Interval
`TargetCamera`	TargetCamera
`RegularPolygon`	RegularPolygon
`CustomCursor`	CustomCursor
`Vec4`	Vec4
`CascadesFrusta`	CascadesFrusta
`PrimaryWindow`	PrimaryWindow
`Vec2`	Vec2
`DefaultOpaqueRendererMethod`	DefaultOpaqueRendererMethod
`Plane2d`	Plane2d
`WindowTheme`	WindowTheme
`CalculatedClip`	CalculatedClip
`GamepadButtonStateChangedEvent`	GamepadButtonStateChangedEvent
`Range`	Range
`PlaybackMode`	PlaybackMode
`BVec3A`	BVec3A
`ScreenSpaceAmbientOcclusion`	ScreenSpaceAmbientOcclusion
`Rhombus`	Rhombus
`Msaa`	Msaa
`AtomicU64`	AtomicU64
`CursorEntered`	CursorEntered
`DeferredPrepass`	DeferredPrepass
`GridAutoFlow`	GridAutoFlow
`AtomicIsize`	AtomicIsize
`IrradianceVolume`	IrradianceVolume
`CameraMainTextureUsages`	CameraMainTextureUsages
`TextEntity`	TextEntity
`Focus`	Focus
`UiAntiAlias`	UiAntiAlias
`ShaderStorageBuffer`	ShaderStorageBuffer
`Text`	Text
`MouseMotion`	MouseMotion
`AnimationEvent`	AnimationEvent
`CursorGrabMode`	CursorGrabMode
`CubemapVisibleEntities`	CubemapVisibleEntities
`AlphaMode`	AlphaMode
`LineBreak`	LineBreak
`TimedAnimationEvent`	TimedAnimationEvent
`BVec2`	BVec2
`WindowResolution`	WindowResolution
`Line3d`	Line3d
`BackgroundColor`	BackgroundColor
`EntityHash`	EntityHash
`WindowOccluded`	WindowOccluded
`PickingPlugin`	PickingPlugin
`FloatOrd`	FloatOrd
`PathBuf`	PathBuf
`TimerMode`	TimerMode
`PerspectiveProjection`	PerspectiveProjection
`WindowBackendScaleFactorChanged`	WindowBackendScaleFactorChanged
`IVec2`	IVec2
`Srgba`	Srgba
`u128`	u128
`ThreadedAnimationGraph`	ThreadedAnimationGraph
`Ime`	Ime
`NodeImageMode`	NodeImageMode
`Val`	Val
`VisibilityRange`	VisibilityRange
`FunctionReturnInfo`	FunctionReturnInfo
`AtomicU16`	AtomicU16
`BVec3`	BVec3
`Dir2`	Dir2
`Dir3A`	Dir3A
`Hsva`	Hsva
`GlyphAtlasLocation`	GlyphAtlasLocation
`Capsule3d`	Capsule3d
`CursorLeft`	CursorLeft
`ScriptQueryBuilder`	ScriptQueryBuilder
`Duration`	Duration
`OverflowClipBox`	OverflowClipBox
`VisibleMeshEntities`	VisibleMeshEntities
`WindowEvent`	WindowEvent
`OnReplace`	OnReplace
`ComponentId`	ComponentId
`GamepadInput`	GamepadInput
`Camera3dDepthTextureUsage`	Camera3dDepthTextureUsage
`MorphWeights`	MorphWeights
`WindowCreated`	WindowCreated
`RepeatedGridTrack`	RepeatedGridTrack
`Aabb2d`	Aabb2d

Functions

Non-Associated Functions

Global functions that are not associated with any type and callable from anywhere in the script.

For function details and documentation, click on the function link.

Function	Summary
construct	Attempts to construct the given type, given an arbitrary map of values.
system_builder	Creates a new script system builder, which can be used to add new systems to the world.

`construct`

This function is impure, it might potentially try to access anything in the world. If you are using it in the context of a script system, it might cause access errors.

> Attempts to construct the given type, given an arbitrary map of values.

Type	Summary
`World`	The ECS world containing all Components, Resources and Systems. Main point of interaction with a Bev...
`ReflectReference`	A reference to an arbitrary reflected instance. The reference can point to either the ECS, or to ...
`ScriptComponentRegistration`	A reference to a component type's reflection registration. In general think of this as a handle t...
`ScriptQueryBuilder`	The query builder is used to build ECS queries which retrieve spefific components filtered by speci...
`ScriptQueryResult`	A result from a query.
`ScriptResourceRegistration`	A reference to a resource type's reflection registration. In general think of this as a handle to...
`ScriptTypeRegistration`	A reference to a type which is not a `Resource` or `Component`. In general think of this as a han...
`ScriptSystemBuilder`	A builder for systems living in scripts
`ReflectSchedule`	A reflectable schedule.
`ReflectSystem`	A reflectable system.
`Name`	Component used to identify an entity. Stores a hash for faster comparisons. The hash is eagerly r...
`ComponentId`	A value which uniquely identifies the type of a [`Component`] or [`Resource`] within a [`World`]. Each time a new `Component` type is registered within a `World` using e.g. [`World::register_component`]...
`ComponentTicks`	Records when a component or resource was added and when it was last mutably dereferenced (or added)...
`Tick`	A value that tracks when a system ran relative to other systems. This is used to power change dete...
`Entity`	Lightweight identifier of an [entity](crate::entity). The identifier is implemented using a [gene...
`EntityHash`	A [`BuildHasher`] that results in a [`EntityHasher`].
`Identifier`	A unified identifier for all entity and similar IDs. Has the same size as a `u64` integer, but th...
`RemovedComponentEntity`	Wrapper around [`Entity`] for [`RemovedComponents`]. Internally, `RemovedComponents` uses these as...
`Children`	Contains references to the child entities of this entity. Each child must contain a [`Parent`] component that points back to this entity. This component rarely needs to be created manually, consider using higher level utilities like [`BuildChildren::with_children`]...
`Parent`	Holds a reference to the parent entity of this entity. This component should only be present on en...
`HierarchyEvent`	An [`Event`] that is fired whenever there is a change in the world's hierarchy. [`Event`]: bevy_ecs::event::Event
`ButtonState`	The current "press" state of an element
`AxisSettings`	Settings for a [`GamepadAxis`]. It is used inside the [`GamepadSettings`] to define the sensitivi...
`ButtonAxisSettings`	Settings for a [`GamepadButton`]. It is used inside the [`GamepadSettings`] to define the sensiti...
`ButtonSettings`	Manages settings for gamepad buttons. It is used inside [`GamepadSettings`] to define the threshold for a [`GamepadButton`]...
`Gamepad`	Stores a connected gamepad's metadata such as the name and its [`GamepadButton`] and [`GamepadAxis`...
`GamepadAxis`	Represents gamepad input types that are mapped in the range [-1.0, 1.0] ## Usage This is used to determine which axis has changed its value when receiving a gamepad axis event. It is also used in the [`Gamepad`]...
`GamepadAxisChangedEvent`	[`GamepadAxis`] event triggered by an analog state change
`GamepadButton`	Represents gamepad input types that are mapped in the range [0.0, 1.0]. ## Usage This is used to determine which button has changed its value when receiving gamepad button events It is also used in the [`Gamepad`]...
`GamepadButtonChangedEvent`	[`GamepadButton`] event triggered by an analog state change
`GamepadButtonStateChangedEvent`	[`GamepadButton`] event triggered by a digital state change
`GamepadConnection`	The connection status of a gamepad.
`GamepadConnectionEvent`	A Gamepad connection event. Created when a connection to a gamepad is established and when a gamep...
`GamepadEvent`	A gamepad event. This event type is used over the [`GamepadConnectionEvent`], [`GamepadButtonChangedEvent`...
`GamepadInput`	Encapsulation over [`GamepadAxis`] and [`GamepadButton`]
`GamepadRumbleIntensity`	The intensity at which a gamepad's force-feedback motors may rumble.
`GamepadRumbleRequest`	An event that controls force-feedback rumbling of a [`Gamepad`] [`entity`](Entity). # Notes Doe...
`GamepadSettings`	Gamepad settings component. ## Usage It is used to create a `bevy` component that stores the se...
`RawGamepadAxisChangedEvent`	[`GamepadAxis`] changed event unfiltered by [`GamepadSettings`]
`RawGamepadButtonChangedEvent`	[`GamepadButton`] changed event unfiltered by [`GamepadSettings`]

Name	Type	Documentation
entity	Entity	The entity to check.
registration	ScriptComponentRegistration	The component to check for.

Bevy Scripting